package com.heima.wemedia.service.impl;

import com.alibaba.fastjson.JSON;
import com.heima.apis.article.IArticleClient;
import com.heima.apis.user.IUserClient;
import com.heima.model.article.dtos.ArticleCommentDto;
import com.heima.model.article.pojos.ApArticle;
import com.heima.model.comment.dtos.*;
import com.heima.model.common.dtos.PageResponseResult;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;
import com.heima.model.user.pojos.ApUser;
import com.heima.model.wemedia.pojos.WmUser;
import com.heima.utils.thread.AppThreadLocalUtil;
import com.heima.utils.thread.WmThreadLocalUtil;
import com.heima.wemedia.pojos.*;
import com.heima.wemedia.mapper.WmUserMapper;
import com.heima.wemedia.service.CommentManageService;
import com.mongodb.client.result.DeleteResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class CommentManageServiceImpl implements CommentManageService {


    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private IArticleClient articleClient;

    /**
     * 查询文章评论的状态(评论管理分页查询，展示文章标题，评论状态，评论总量。。)
     * @param dto
     * @return
     */
    @Override
    public PageResponseResult findNewsComments(ArticleCommentDto dto) {
        WmUser user = WmThreadLocalUtil.getUser();
        dto.setWmUserId(user.getId());
        return articleClient.findNewsComments(dto);
    }

    /**
     * 打开或关闭评论
     * @param dto
     * @return
     */
    @Override
    public ResponseResult updateCommentStatus(CommentConfigDto dto) {
        log.info("打开或关闭评论，参数：{}",dto);
        // 参数验证
        if (dto == null || dto.getArticleId() == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"文章id不能为空");
        }

        WmUser wmUser = WmThreadLocalUtil.getUser();
        log.info("通过WmThreadLocalUtil.getUser()获取的自媒体端用户的信息wmUser只有id(不满足要求): {}",
                wmUser);
        //获取该自媒体端用户所关联的app端的用户id(自己在app端的账号id)
        WmUser dbUser = wmUserMapper.selectById(wmUser.getId());
        if (dbUser.getApUserId() == null) {
            log.error("自媒体端用户{}没有关联app端的用户",
                    wmUser.getName());
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,
                    "该自媒体端用户没有关联app端的用户");
        }
        Integer apUserId = dbUser.getApUserId();
        log.info("该自媒体人的app端ID是：{}",apUserId);
        //TODO 关闭打开都要清空该文章的所有评论
        //先找到该文章下的所有评论
        List<ApComment> apCommentList = mongoTemplate.find//entryId是评论对象ApComment的文章id(标注这条评论是出自哪个文章..)
                (Query.query(Criteria.where("entryId").is(dto.getArticleId())),
                        //先把所有评论都找出来(包括自己的)
                        //只要自己的文章的评论都要删除(除了自己的评论)
                        ApComment.class);
        log.info("遍历该文章下的总共{}条评论",apCommentList.size());
        for (ApComment apComment : apCommentList) {
            log.info("开始删除评论<{}>的相关内容",apComment.getContent());
            //找到每条评论下的所有回复评论
            List<ApCommentRepay> commentRepayList = mongoTemplate.find
                    (Query.query(Criteria.where("commentId")
                            .is(apComment.getId())),
                            //只要自己的文章的回复评论都要删除(自己的评论也要删除)
                            ApCommentRepay.class);
            //获取所有回复评论的id集合
            List<String> commentRepayIdList = commentRepayList.stream()
                    //.distinct()是去重，只取唯一的id值
                    .map(ApCommentRepay::getId).distinct().collect(Collectors.toList());
            log.info("开始删除该评论下的所有回复评论的{}个点赞数据",commentRepayIdList.size());
            //删除所有的回复评论的点赞数据
            DeleteResult result1 = mongoTemplate.remove(Query.query
                    (Criteria.where("commentRepayId")
                            //回复评论的id集合
                            // (因为一次循环只处理一条评论，
                            // 一条评论下有多条回复，
                            // 多条回复就有多种点赞数据)
                            .in(commentRepayIdList)),
                            //只要自己的文章的回复评论的点赞数据都要删除(自己的评论的点赞数据也要删除)
                    //APP评论回复信息点赞信息对象
                    ApCommentRepayLike.class);
            if (result1.wasAcknowledged()) {
                log.info("删除了{}条该评论下的所有回复评论的点赞数据",result1.getDeletedCount());
            }
            log.info("开始删除该评论下的所有回复评论");
            //删除该评论的所有的回复内容
            DeleteResult result2 = mongoTemplate.remove(Query.query
                    //回复评论没有文章id，不能用entryId，应该用评论Id来删除
                    (Criteria.where("commentId")
                            //需要是自己的文章的评论
                            .is(apComment.getId())),
                            //只要自己的文章的回复评论都要删除(自己的回复评论也要删除)
                    ApCommentRepay.class);
            if (result2.wasAcknowledged()) {
                log.info("删除了{}条回复评论",result2.getDeletedCount());
            }
            log.info("开始删除该评论下的所有点赞数据");
            //TODO 实现自己给自己的评论点的赞的数据不删(要把自己的评论都查出来？？)
            //删除该评论的点赞数据
            DeleteResult result3 = mongoTemplate.remove(Query.query
                    (Criteria.where("commentId").is(apComment.getId())),
                    //(因为一条评论只有一种点赞数据)
                    ApCommentLike.class);
            if (result3.wasAcknowledged()) {
                log.info("删除了{}条评论的点赞数据",result3.getDeletedCount());
            }
            //初始化该评论的点赞数量，回复数量等属性数据
            apComment.setLikes(0);
            apComment.setReply(0);
            //更新到数据库,
            // mongoTemplate.save 方法会根据文档的 _id 字段来决定是插入一条新文档还是更新已存在的文档。
            // 如果提供的对象的 _id 字段存在且匹配到数据库中的文档，save 方法会覆盖原有的文档；
            // 如果 _id 字段不存在或未匹配到任何文档，则会插入一条新的文档。
//          apArticleService.save()不会覆盖原有的，会报错
            mongoTemplate.save(apComment);
        }
        //所有评论已经遍历过了，把所有评论下的所有回复，
        // 点赞数据以及每条评论自己的点赞数据都删除了，就可以把文章的评论全部删除了
        log.info("把别人写的所有评论下的所有回复，回复评论的点赞数据以及" +
                "每条评论的点赞数据都删除了，开始删除该文章下的所有评论(除了自己的)");
        DeleteResult result4 = mongoTemplate.remove(Query.query
                (Criteria.where("entryId").is(dto.getArticleId())
                        .and("authorId").ne(apUserId)),ApComment.class);
        if (result4.wasAcknowledged()) {
            log.info("删除了{}条评论数据",result4.getDeletedCount());
        }
        //清理残留数据，增加软件健壮性????影响性能。。。

        //最后修改app文章的config配置(更新文章评论状态(CommentConfigDto.grtOperation()
        // 0  关闭评论 1  开启评论))
        return articleClient.updateCommentStatus(dto);
    }

    /**
     * 自媒体人查询自己文章的评论列表(详情)
     * @return
     */
    @Override
    public ResponseResult list(CommentManageDto dto) {
        log.info("自媒体人查询自己文章的评论列表详情，参数：{}",dto);
        log.info("自媒体人查询自己文章的评论列表详情，分页参数：{},{}",dto.getPage(),dto.getSize());

        // 参数验证
        if (dto == null || dto.getArticleId() == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"文章id不能为空");
        }

        //用于存储所有评论ApComment以及每条评论下的所有回复评论(List<ApCommentRepay>)。
        List<CommentRepayListVo> commentRepayListVoList = new ArrayList<>();

        //查询条件是 entryId 等于传入的文章 ID (dto.getArticleId())，
        // 用于查找与特定文章相关的评论。
        Query query = Query.query(Criteria.where("entryId")
                .is(dto.getArticleId()));
        log.info("dto.getArticleId()是 {}",dto.getArticleId());
        //创建一个分页请求，使用传入的页码和每页大小。
        dto.checkParam();//如果dto的参数不符合要求，则给个默认值
//        log.info("分页参数填充了吗：{}",dto);
//        Page 的索引是从 0 开始的。换句话说，当 page 为 1 时，
//        实际应该使用 PageRequest.of(dto.getPage() - 1, dto.getSize()) 来确保正确的分页。
        Pageable pageable = PageRequest.of(dto.getPage() - 1,dto.getSize());
//        //将分页信息添加到查询中。
        query.with(pageable);
//        //将排序条件添加到查询中，按 createdTime 字段降序排列。
        query.with(Sort.by(Sort.Direction.DESC, "createdTime"));

        //获取与文章 ID 相关的评论列表，结果存储在 list 中。
        List<ApComment> list = mongoTemplate.find(query, ApComment.class);
        log.info("查询到该文章下的评论{}",list);
        //遍历每条评论并获取每条评论的回复评论
        for (ApComment apComment : list) {
            CommentRepayListVo vo = new CommentRepayListVo();
            //存入评论信息
            vo.setApComments(apComment);
            Query query2 = Query.query(Criteria.where("commentId")
                    .is(apComment.getId()));
            //按 createdTime 降序排列(最新的评论在前面)
            query2.with(Sort.by(Sort.Direction.DESC, "createdTime"));
            //获取每一条评论下的所有回复评论
            List<ApCommentRepay> apCommentRepays = mongoTemplate
                    .find(query2, ApCommentRepay.class);
            //存入回复评论的列表
            vo.setApCommentRepays(apCommentRepays);
            //将包含评论和其对应的回复评论，
            // 一起存入commentRepayListVoList(特地为了展示评论和其对应的回复评论而创建的)中
            commentRepayListVoList.add(vo);
        }

        return ResponseResult.okResult(commentRepayListVoList);
    }

    /**
     * 删除评论
     * @param commentId
     * @return
     */
    @Override
    public ResponseResult delComment(String commentId) {
        if(StringUtils.isBlank(commentId)){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"评论id不能为空");
        }
        //如果指定的查询条件
        // （即 Query.query(Criteria.where("commentId").is(commentId))）
        // 没有找到任何匹配的数据，MongoDB 不会抛出错误
        //mongoTemplate.remove() 返回一个 DeleteResult 对象
//        DeletedCount: 删除操作中实际删除的文档数量。
//        如果没有找到任何匹配的文档，则 DeletedCount 将为 0。

        //先根据传来的commentId找到这条评论的所有回复评论的commentRepayId(List集合)
        List<String> commentRepayIdList = mongoTemplate.find(Query.query
                        (Criteria.where("commentId").is(commentId)), ApCommentRepay.class)
                .stream().map(ApCommentRepay::getId).collect(Collectors.toList());
        //删除该条评论的所有回复评论的所有点赞数据？？？需要？？？
        DeleteResult result1 = mongoTemplate.remove(Query.query
                (Criteria.where("commentRepayId").in(commentRepayIdList)),
                //commentRepayId表明是给那条回复评论点的赞
                ApCommentRepayLike.class);
        if (result1.wasAcknowledged()) {
            // 没有找到匹配的文档，执行相应的逻辑if (result1.getDeletedCount() == 0) {
            log.info("删除了{}条回复评论的点赞记录",result1.getDeletedCount());
        }

        //删除该评论下的所有的回复内容
        DeleteResult result2 = mongoTemplate.remove(Query.query
                (Criteria.where("commentId").is(commentId)),
                //commentId表明是在那条评论下的回复
                ApCommentRepay.class);
        if (result2.wasAcknowledged()) {
            // 没有找到匹配的文档，执行相应的逻辑if (result2.getDeletedCount() == 0) {
            log.info("删除了{}条回复评论",result2.getDeletedCount());
        }
        //删除评论的所有点赞数据？？？需要？？？
        DeleteResult result3 = mongoTemplate.remove(Query.query
                (Criteria.where("commentId").is(commentId)),
                //commentId表明是给那条评论点的赞
                ApCommentLike.class);
        if (result3.wasAcknowledged()) {
            // 没有找到匹配的文档，执行相应的逻辑if (result3.getDeletedCount() == 0) {
            log.info("删除了{}条评论的点赞数据",result3.getDeletedCount());
        }
        //删除评论
        DeleteResult result4 = mongoTemplate.remove(Query.query
                (Criteria.where("id").is(commentId)),
                ApComment.class);
        if (result4.wasAcknowledged()) {
            // 没有找到匹配的文档，执行相应的逻辑if (result4.getDeletedCount() == 0) {
            log.info("删除了{}条评论",result4.getDeletedCount());
        }

        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }

    /**
     * 删除评论回复(前端未实现)
     * @param commentRepayId
     * @return
     */
    @Override
    public ResponseResult delCommentRepay(String commentRepayId) {
        if(StringUtils.isBlank(commentRepayId)){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"评论回复id不能为空");
        }
        //删除该回复评论的所有点赞数据？？？需要？？？
        DeleteResult result = mongoTemplate.remove(Query.query(Criteria.where("commentRepayId")
                .is(commentRepayId)),ApCommentRepayLike.class);
        if (result.getDeletedCount() == 0) {
            // 没有找到匹配的文档，执行相应的逻辑
            log.info("没有找到回复评论的点赞记录");
        }
        //删除回复评论
        DeleteResult result1 = mongoTemplate.remove(Query.query(Criteria.where("id")
                .is(commentRepayId)),ApCommentRepay.class);
        if (result1.getDeletedCount() == 0) {
            // 没有找到匹配的文档，执行相应的逻辑
            log.info("没有找到回复评论");
        }
        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }

    @Autowired
    private IUserClient userClient;

    @Autowired
    private WmUserMapper wmUserMapper;

    /**
     * 回复评论(作者可以对自己的某一条评论进行回复)
     * @param dto
     * @return
     */
    @Override
    public ResponseResult saveCommentRepay(CommentRepaySaveDto dto) {
        log.info("作者回复：{}",dto);
        //1.检查参数
        if(dto == null || StringUtils.isBlank(dto.getContent()) || dto.getCommentId() == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        if(dto.getContent().length() > 150){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"评论内容不能超过150字");
        }

        //2.TODO 安全检查 垃圾文本检测


        //获取自己的自媒体端的用户信息
        WmUser wmUser = WmThreadLocalUtil.getUser();
        //WmThreadLocalUtil.getUser()里面只有id
        WmUser dbUser = wmUserMapper.selectById(wmUser.getId());
        if(dbUser == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }

        //获取自媒体人自己的app端的用户信息
//        ApUser apUser = userClient.findUserById(dbUser.getApUserId());
        ResponseResult responseResult = userClient.findUserById(dbUser.getApUserId());
        log.info("远程接口查询到的app端用户信息返回结果：{}",responseResult.getData());
        ApUser apUser = null;
        log.info("responseResult.getCode()是：{}",responseResult.getCode());
        if(responseResult.getCode().equals(200)){
            log.info("远程接口调用成功");
            //获得app端用户信息(json数据)
            String apUserJson = JSON.toJSONString(responseResult.getData());
            //转换成对象
            apUser = JSON.parseObject(apUserJson, ApUser.class);
            //通过用户ID查找当前登录用户的信息。如果用户不存在，则返回错误信息。
            if (apUser == null) {
                log.info("该媒体人的app端并没有注册");
                return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "该媒体人的app端没有注册");
            }
            //ApUser dbUser = userClient.findUserById(user.getId());
        }

        //3.保存评论
        ApCommentRepay apCommentRepay = new ApCommentRepay();
        //(评论是自己发的，填自己在app端账号的id作为评论的作者id)
        apCommentRepay.setAuthorId(apUser.getId());
        //发回复评论的用户
        apCommentRepay.setAuthorName(apUser.getName());

        apCommentRepay.setContent(dto.getContent());
        apCommentRepay.setCreatedTime(new Date());
        apCommentRepay.setCommentId(dto.getCommentId());

        apCommentRepay.setUpdatedTime(new Date());
        //初始化点赞数量
        apCommentRepay.setLikes(0);
        mongoTemplate.save(apCommentRepay);

        //5更新回复数量
        ApComment apComment = mongoTemplate.findById(dto.getCommentId(), ApComment.class);
        apComment.setReply(apComment.getReply()+1);
        mongoTemplate.save(apComment);

        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }


    /**
     * 自媒体人给自己文章的评论点赞(不能给回复点赞？)
     * @param dto
     * @return
     */
    @Override
    public ResponseResult like(CommentLikeDto dto) {
        //1.检查参数
        if (dto == null || dto.getCommentId() == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        //查一下有没有该评论
        ApComment apComment = mongoTemplate.findById(dto.getCommentId(),
                ApComment.class);

        //2.获取(自己)自媒体人的信息(验证是否已登录)
        WmUser wmUser = WmThreadLocalUtil.getUser();
        WmUser dbUser = wmUserMapper.selectById(wmUser.getId());
        if(dbUser == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }

        //获取自己在app端用户信息
//        ApUser apUser = userClient.findUserById(dbUser.getApUserId());
        ResponseResult responseResult = userClient.findUserById(dbUser.getApUserId());
        log.info("远程接口查询到的app端用户信息返回结果：{}",responseResult.getData());
        ApUser apUser = null;
        if(responseResult.getCode().equals(200)){//远程接口调用成功
            log.info("远程接口调用成功");
            //获得app端用户信息(json数据)
            String apUserJson = JSON.toJSONString(responseResult.getData());
            //转换成对象
            apUser = JSON.parseObject(apUserJson, ApUser.class);
            //通过用户ID查找当前登录用户的信息。如果用户不存在，则返回错误信息。
            if (apUser == null) {
                log.info("该媒体人的app端并没有注册");
                return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "该媒体人的app端没有注册");
            }
            //ApUser dbUser = userClient.findUserById(user.getId());
        }

        //3.点赞 Operation 0：点赞
        if (apComment != null && dto.getOperation() == 0) {
            //更新评论点赞数量
            apComment.setLikes(apComment.getLikes() + 1);
            mongoTemplate.save(apComment);

            //保存评论点赞数据(记录是谁点的赞(是作者点的))
            ApCommentLike apCommentLike = new ApCommentLike();
            apCommentLike.setCommentId(apComment.getId());
            apCommentLike.setAuthorId(apUser.getId());
            mongoTemplate.save(apCommentLike);
        } else {
            //Operation 1：取消点赞
            int tmp = apComment.getLikes() - 1;
            //确保点赞数不会小于0。
            tmp = tmp < 1 ? 0 : tmp;
            //更新评论点赞数量
            apComment.setLikes(tmp);
            mongoTemplate.save(apComment);

            //删除评论点赞数据(取消点赞之后，就不知道之前是谁点的赞了)
            Query query = Query.query(Criteria.where("commentId")
                    .is(apComment.getId()).and("authorId").is(apUser.getId()));
            mongoTemplate.remove(query, ApCommentLike.class);
        }

        Map<String, Object> result = new HashMap<>();
        //将 apComment 对象的点赞数（通过 getLikes() 方法获取）
        // 放入 result 这个 Map 中。键为 "likes"，值为当前的点赞数。
        result.put("likes", apComment.getLikes());
        return ResponseResult.okResult(result);
    }

    /**
     * 对评论回复的点赞(点赞数 + 1 |记录是谁点的赞)
     * @param dto (评论id + 0.点赞1：取消点赞)
     * @return
     */
    @Override
    public ResponseResult RepayLike(CommentRepayLikeDto dto) {
        //1.检查参数
        if(dto == null || dto.getCommentRepayId() == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        //2.判断用户(点赞的那个人)是否登录
//        ApUser user = AppThreadLocalUtil.getUser();
//        if(user == null){
//            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
//        }

        //查找指定commentRepayId的评论回复对象apCommentRepay。
//        ApCommentRepay apCommentRepay = mongoTemplate.findById(dto.getCommentRepayId(),
//              ApCommentRepay.class);

        //--------------
        //查一下有没有该回复评论
        ApCommentRepay apCommentRepay = mongoTemplate.findById(dto.getCommentRepayId(),
                ApCommentRepay.class);

        //2.获取(自己)自媒体人的信息(验证用户(点赞的那个人)是否已登录)
        WmUser wmUser = WmThreadLocalUtil.getUser();
        WmUser dbUser = wmUserMapper.selectById(wmUser.getId());
        if(dbUser == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }

        //获取自己在app端用户信息
//        ApUser apUser = userClient.findUserById(dbUser.getApUserId());
        ResponseResult responseResult = userClient.findUserById(dbUser.getApUserId());
        log.info("远程接口查询到的app端用户信息返回结果：{}",responseResult.getData());
        ApUser apUser = null;
        if(responseResult.getCode().equals(200)){//远程接口调用成功
            log.info("远程接口调用成功");
            //获得app端用户信息(json数据)
            String apUserJson = JSON.toJSONString(responseResult.getData());
            //转换成对象
            apUser = JSON.parseObject(apUserJson, ApUser.class);
            //通过用户ID查找当前登录用户的信息。如果用户不存在，则返回错误信息。
            if (apUser == null) {
                log.info("该媒体人的app端并没有注册");
                return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "该媒体人的app端没有注册");
            }
            //ApUser dbUser = userClient.findUserById(user.getId());
        }


        //3.点赞  0：点赞  1：取消点赞
        //检查apCommentRepay是否存在且操作类型是否为点赞（dto.getOperation() == 0）
        if(apCommentRepay != null && dto.getOperation() == 0){
            //是点赞，将评论回复的likes数量加1
            apCommentRepay.setLikes(apCommentRepay.getLikes()+1);
            mongoTemplate.save(apCommentRepay);

            //不仅仅要增加点赞数，还需要记录当前用户对于当前评论的点赞数据记录
            //保存评论点赞数据(记录是谁点的赞)
            ApCommentRepayLike apCommentRepayLike = new ApCommentRepayLike();
            apCommentRepayLike.setCommentRepayId(apCommentRepay.getId());
            apCommentRepayLike.setAuthorId(apUser.getId());
            mongoTemplate.save(apCommentRepayLike);
        }else {
            //是取消点赞，更新评论点赞数量
            int tmp = apCommentRepay.getLikes()-1;
            //确保点赞数量不小于0。
            tmp = tmp < 1 ? 0 : tmp;
            apCommentRepay.setLikes(tmp);
            mongoTemplate.save(apCommentRepay);

            //删除该用户的回复评论的点赞记录
            //构建一个查询来查找数据库中与当前评论回复ID和用户ID匹配的点赞记录
            Query query = Query.query(Criteria.where("commentRepayId")
                    .is(apCommentRepay.getId()).and("authorId").is(apUser.getId()));
            mongoTemplate.remove(query,ApCommentRepayLike.class);
        }

        //4.取消点赞
        Map<String,Object> result = new HashMap<>();
        log.info("更新后的点赞数量：{}",apCommentRepay.getLikes());
        result.put("likes",apCommentRepay.getLikes());
        return ResponseResult.okResult(result);
    }
}
